package com.cursor.service;

import com.cursor.entity.LicenseKeys;
import com.cursor.repository.LicenseKeysRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class LicenseKeysService {
    
    private final LicenseKeysRepository licenseKeysRepository;
    
    public Optional<LicenseKeys> getLicenseByKey(String key) {
        return licenseKeysRepository.findByKey(key);
    }
    
    public String getRemainingDays(LocalDate expiryDate) {
        if (expiryDate == null) {
            return "永久";
        }
        
        long days = ChronoUnit.DAYS.between(LocalDate.now(), expiryDate);
        if (days < 0) {
            return "已过期";
        }
        return days + "天";
    }
    
    /**
     * 激活许可证
     * @param key 许可证密钥
     * @return 成功返回true，失败返回false
     */
    @Transactional
    public boolean activateLicense(String key) {
        Optional<LicenseKeys> licenseOpt = licenseKeysRepository.findByKey(key);
        
        if (!licenseOpt.isPresent()) {
            return false;
        }
        
        LicenseKeys license = licenseOpt.get();
        // 检查许可证是否已激活
        if (license.getActivationStatus() != null && license.getActivationStatus() == 1) {
            return true; // 已经激活过，视为成功
        }
        
        // 激活许可证
        license.setActivationStatus(1);
        license.setActivationDate(LocalDate.now());
        
        // 如果有设置有效天数，则计算到期日期
        if (license.getValidDays() != null && license.getValidDays() > 0) {
            license.setExpiryDate(LocalDate.now().plusDays(license.getValidDays()));
        } else {
            // 如果没有设置有效天数，可以设置为null表示永久有效，或者设置一个默认值
            // license.setExpiryDate(null); // 永久有效
            license.setExpiryDate(LocalDate.now().plusDays(30)); // 默认30天
        }
        
        licenseKeysRepository.save(license);
        return true;
    }
    
    /**
     * 检查许可证是否已激活
     * @param key 许可证密钥
     * @return 已激活返回true，未激活返回false
     */
    public boolean isLicenseActivated(String key) {
        Optional<LicenseKeys> licenseOpt = licenseKeysRepository.findByKey(key);
        if (!licenseOpt.isPresent()) {
            return false;
        }
        
        LicenseKeys license = licenseOpt.get();
        return license.getActivationStatus() != null && license.getActivationStatus() == 1;
    }

    /**
     * 根据激活状态和到期时间判断许可证状态
     * @param license 许可证对象
     * @return 状态描述：已激活、未激活、已过期
     */
    public String getLicenseStatus(LicenseKeys license) {
        // 如果未激活，返回"未激活"
        if (license.getActivationStatus() == null || license.getActivationStatus() == 0) {
            return "未激活";
        }
        
        // 已激活，检查是否过期
        if (license.getExpiryDate() == null) {
            return "已激活"; // 无到期日期视为永久有效
        }
        
        // 比较当前日期与到期日期
        if (LocalDate.now().isAfter(license.getExpiryDate())) {
            return "已过期";
        }
        
        return "已激活";
    }

    /**
     * 扣除许可证积分
     * @param key 许可证密钥
     * @param points 需要扣除的积分
     * @return 是否扣除成功
     */
    @Transactional
    public boolean deductPoints(String key, int points) {
        Optional<LicenseKeys> licenseOpt = licenseKeysRepository.findByKey(key);
        
        if (!licenseOpt.isPresent()) {
            return false;
        }
        
        LicenseKeys license = licenseOpt.get();
        
        // 检查许可证状态
        String status = getLicenseStatus(license);
        if (!"已激活".equals(status)) {
            return false; // 如果许可证未激活或已过期，不能扣积分
        }
        
        // 检查可用积分是否足够
        int availablePoints = license.getCursorPoolUsageTotal() - license.getCursorPoolUsageUsed();
        if (availablePoints < points) {
            return false; // 积分不足
        }
        
        // 扣除积分
        license.setCursorPoolUsageUsed(license.getCursorPoolUsageUsed() + points);
        licenseKeysRepository.save(license);
        
        return true;
    }

    /**
     * 获取许可证剩余积分
     * @param license 许可证对象
     * @return 剩余积分
     */
    public int getRemainingPoints(LicenseKeys license) {
        return license.getCursorPoolUsageTotal() - license.getCursorPoolUsageUsed();
    }

    /**
     * 检查许可证是否有足够的积分
     * @param key 许可证密钥
     * @param requiredPoints 需要的积分
     * @return 是否有足够积分
     */
    public boolean hasEnoughPoints(String key, int requiredPoints) {
        Optional<LicenseKeys> licenseOpt = licenseKeysRepository.findByKey(key);
        
        if (!licenseOpt.isPresent()) {
            return false;
        }
        
        LicenseKeys license = licenseOpt.get();
        return getRemainingPoints(license) >= requiredPoints;
    }
} 